Manajemen Sumber Daya Generator Async JavaScript: Pembersihan Sumber Daya Stream untuk Aplikasi yang Tangguh

            async function* generateNumbers(count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Mensimulasikan operasi asinkron
    yield i;
  }
}

(async () => {
  for await (const number of generateNumbers(5)) {
    console.log(number);
  }
})();

            

              
                Copy
              
            
          

            async function* processStream(stream) {
  try {
    // Proses stream
    while (true) {
      const chunk = await stream.read();
      if (!chunk) break;
      yield processChunk(chunk);
    }
  } finally {
    // Kode pembersihan: Tutup stream
    if (stream) {
      await stream.close();
      console.log('Stream ditutup.');
    }
  }
}

            

              
                Copy
              
            
          

            const fs = require('fs');
const { Readable } = require('stream');

async function* processFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    for await (const chunk of fileStream) {
      yield chunk.toString();
    }
  } finally {
    if (fileStream) {
      fileStream.close(); // Gunakan close untuk stream yang dibuat oleh fs
      console.log('File stream ditutup.');
    }
  }
}

(async () => {
  const filePath = 'example.txt'; // Ganti dengan path file Anda
  fs.writeFileSync(filePath, 'Ini adalah contoh konten.\nDengan banyak baris.\nUntuk mendemonstrasikan pemrosesan stream.');

  for await (const line of processFile(filePath)) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

            async function withResource(resourceFactory, generatorFunction) {
  let resource;
  try {
    resource = await resourceFactory();
    for await (const value of generatorFunction(resource)) {
      yield value;
    }
  } finally {
    if (resource) {
      await resource.cleanup();
      console.log('Sumber daya dibersihkan.');
    }
  }
}

            

              
                Copy
              
            
          

            class CustomStream {
  constructor() {
    this.data = ['Baris 1', 'Baris 2', 'Baris 3'];
    this.index = 0;
  }

  async read() {
    await new Promise(resolve => setTimeout(resolve, 50)); // Mensimulasikan pembacaan async
    if (this.index < this.data.length) {
      return this.data[this.index++];
    } else {
      return null;
    }
  }

  async cleanup() {
    console.log('Pembersihan CustomStream selesai.');
  }
}

async function* processCustomStream(stream) {
  while (true) {
    const chunk = await stream.read();
    if (!chunk) break;
    yield `Diproses: ${chunk}`;
  }
}

async function withResource(resourceFactory, generatorFunction) {
  let resource;
  try {
    resource = await resourceFactory();
    for await (const value of generatorFunction(resource)) {
      yield value;
    }
  } finally {
    if (resource && resource.cleanup) {
      await resource.cleanup();
      console.log('Sumber daya dibersihkan.');
    }
  }
}


(async () => {
  for await (const line of withResource(() => new CustomStream(), processCustomStream)) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

            async function* processStreamWithAbort(stream, signal) {
  try {
    while (!signal.aborted) {
      const chunk = await stream.read();
      if (!chunk) break;
      yield processChunk(chunk);
    }
  } finally {
    if (stream) {
      await stream.close();
      console.log('Stream ditutup.');
    }
  }
}

(async () => {
  const controller = new AbortController();
  const { signal } = controller;

  // Mensimulasikan batas waktu
  setTimeout(() => {
    console.log('Menghentikan pemrosesan stream...');
    controller.abort();
  }, 2000);

  const stream = createSomeStream(); // Ganti dengan logika pembuatan stream Anda

  try {
    for await (const chunk of processStreamWithAbort(stream, signal)) {
      console.log('Chunk:', chunk);
    }
  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Pemrosesan stream dibatalkan.');
    } else {
      console.error('Kesalahan memproses stream:', error);
    }
  }
})();

            

              
                Copy
              
            
          

            async function* processStreamWithErrorHandling(stream) {
  try {
    while (true) {
      try {
        const chunk = await stream.read();
        if (!chunk) break;
        yield processChunk(chunk);
      } catch (error) {
        console.error('Kesalahan memproses chunk:', error);
        // Secara opsional, Anda dapat memilih untuk melempar ulang kesalahan atau melanjutkan pemrosesan
        // throw error;
      }
    }
  } finally {
    if (stream) {
      try {
        await stream.close();
        console.log('Stream ditutup.');
      } catch (closeError) {
        console.error('Kesalahan menutup stream:', closeError);
      }
    }
  }
}

            

              
                Copy
              
            
          

            const fs = require('fs');
const cleanup = require('node-cleanup');

async function* processFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    for await (const chunk of fileStream) {
      yield chunk.toString();
    }
  } finally {
    //Ini mungkin tidak selalu berfungsi karena proses mungkin berakhir tiba-tiba.
    //Menggunakan try...finally di generator itu sendiri lebih disukai.
  }
}


(async () => {
  const filePath = 'example.txt'; // Ganti dengan path file Anda
  fs.writeFileSync(filePath, 'Ini adalah contoh konten.\nDengan banyak baris.\nUntuk mendemonstrasikan pemrosesan stream.');

  const stream = processFile(filePath);
  let fileStream = fs.createReadStream(filePath);

  cleanup(function (exitCode, signal) {
        // bersihkan file, hapus entri database, dll
    fileStream.close();
    console.log('File stream ditutup oleh node-cleanup.');
    cleanup.uninstall(); //Hapus komentar untuk mencegah pemanggilan callback ini lagi (info lebih lanjut di bawah)
    return false;
});

  for await (const line of stream) {
    console.log(line);
  }
})();

            

              
                Copy
              
            
          

            const { Pool } = require('pg');

async function* streamDataFromDatabase(query) {
  const pool = new Pool({ /* detail koneksi */ });
  let client;
  try {
    client = await pool.connect();
    const result = await client.query(query);
    for (const row of result.rows) {
      yield row;
    }
  } finally {
    if (client) {
      client.release(); // Kembalikan klien ke pool
      console.log('Koneksi database dilepaskan.');
    }
    await pool.end(); // Tutup pool
    console.log('Pool database ditutup.');
  }
}

(async () => {
  for await (const row of streamDataFromDatabase('SELECT * FROM users')) {
    console.log(row);
  }
})();

            

              
                Copy
              
            
          

            const fs = require('fs');
const csv = require('csv-parser');

async function* processCsvFile(filePath) {
  let fileStream;
  try {
    fileStream = fs.createReadStream(filePath);
    const parser = csv();
    fileStream.pipe(parser);

    for await (const row of parser) {
      yield row;
    }
  } finally {
    if (fileStream) {
      fileStream.close(); // Menutup stream dengan benar
      console.log('Stream file CSV ditutup.');
    }
  }
}

(async () => {
  const filePath = 'data.csv'; // Ganti dengan path file CSV Anda
  fs.writeFileSync(filePath, 'header1,header2\nvalue1,value2\nvalue3,value4');

  for await (const row of processCsvFile(filePath)) {
    console.log(row);
  }
})();

            

              
                Copy
              
            
          

            const https = require('https');

async function* streamDataFromApi(url) {
  let responseStream;
  try {
    const promise = new Promise((resolve, reject) => {
      https.get(url, (res) => {
        responseStream = res;
        res.on('data', (chunk) => {
          resolve(chunk.toString());
        });

        res.on('end', () => {
          resolve(null);
        });

        res.on('error', (error) => {
          reject(error);
        });

      }).on('error', (error) => {
        reject(error);
      });
    });

    while(true) {
      const chunk = await promise; //Await the promise, it returns a chunk.
      if (!chunk) break;
      yield chunk;
    }
  } finally {
      if (responseStream && typeof responseStream.destroy === 'function') { // Check if destroy exists for safety.
          responseStream.destroy();
          console.log('API stream dihancurkan.');
      }
  }
}

(async () => {
  // Gunakan API publik yang mengembalikan data yang dapat di-stream (misalnya, file JSON besar)
  const apiUrl = 'https://jsonplaceholder.typicode.com/todos/1';

  for await (const chunk of streamDataFromApi(apiUrl)) {
    console.log('Chunk:', chunk);
  }
})();

            

              
                Copy